home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Menus.p < prev    next >
Encoding:
Text File  |  1996-05-01  |  10.8 KB  |  406 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Menus.p
  3.  
  4.      Contains:    Menu Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Menus;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __MENUS__}
  28. {$SETC __MENUS__ := 1}
  29.  
  30. {$I+}
  31. {$SETC MenusIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __MEMORY__}
  35. {$I Memory.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __QUICKDRAW__}
  38. {$I Quickdraw.p}
  39. {$ENDC}
  40.  
  41. {$PUSH}
  42. {$ALIGN MAC68K}
  43. {$LibExport+}
  44.  
  45. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  46.  
  47. CONST
  48.     noMark                        = 0;                            { mark symbol for MarkItem }
  49.                                                                 {  menu defProc messages  }
  50.     mDrawMsg                    = 0;
  51.     mChooseMsg                    = 1;
  52.     mSizeMsg                    = 2;
  53.     mDrawItemMsg                = 4;
  54.     mCalcItemMsg                = 5;
  55.     textMenuProc                = 0;
  56.     hMenuCmd                    = 27;                            { itemCmd == 0x001B ==> hierarchical menu }
  57.     hierMenu                    = -1;                            { a hierarchical menu - for InsertMenu call }
  58.     mPopUpMsg                    = 3;                            { menu defProc messages - place yourself }
  59.     mctAllItems                    = -98;                            { search for all Items for the given ID }
  60.     mctLastIDIndic                = -99;                            { last color table entry has this in ID field }
  61.  
  62.  
  63. TYPE
  64.     MenuInfoPtr = ^MenuInfo;
  65.     MenuInfo = RECORD
  66.         menuID:                    INTEGER;
  67.         menuWidth:                INTEGER;
  68.         menuHeight:                INTEGER;
  69.         menuProc:                Handle;
  70.         enableFlags:            LONGINT;
  71.         menuData:                Str255;
  72.     END;
  73.  
  74.     MenuPtr                                = ^MenuInfo;
  75.     MenuHandle                            = ^MenuPtr;
  76.     MenuRef                                = MenuHandle;
  77.     MCEntryPtr = ^MCEntry;
  78.     MCEntry = RECORD
  79.         mctID:                    INTEGER;                                { menu ID.  ID = 0 is the menu bar }
  80.         mctItem:                INTEGER;                                { menu Item. Item = 0 is a title }
  81.         mctRGB1:                RGBColor;                                { usage depends on ID and Item }
  82.         mctRGB2:                RGBColor;                                { usage depends on ID and Item }
  83.         mctRGB3:                RGBColor;                                { usage depends on ID and Item }
  84.         mctRGB4:                RGBColor;                                { usage depends on ID and Item }
  85.         mctReserved:            INTEGER;                                { reserved for internal use }
  86.     END;
  87.  
  88.     MCTable                                = ARRAY [0..0] OF MCEntry;
  89.     MCTablePtr                            = ^MCTable;
  90.     MCTableHandle                        = ^MCTablePtr;
  91.     MenuCRsrcPtr = ^MenuCRsrc;
  92.     MenuCRsrc = RECORD
  93.         numEntries:                INTEGER;                                { number of entries }
  94.         mcEntryRecs:            MCTable;                                { ARRAY [1..numEntries] of MCEntry }
  95.     END;
  96.  
  97.     MenuCRsrcHandle                        = ^MenuCRsrcPtr;
  98.     MenuDefProcPtr = ProcPtr;  { PROCEDURE MenuDef(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER); }
  99.  
  100.     MenuBarDefProcPtr = ProcPtr;  { FUNCTION MenuBarDef(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT): LONGINT; }
  101.  
  102.     MenuHookProcPtr = ProcPtr;  { PROCEDURE MenuHook; }
  103.  
  104.     MBarHookProcPtr = Register68kProcPtr;  { FUNCTION MBarHook(VAR menuRect: Rect): INTEGER; }
  105.  
  106.     MenuDefUPP = UniversalProcPtr;
  107.     MenuBarDefUPP = UniversalProcPtr;
  108.     MenuHookUPP = UniversalProcPtr;
  109.     MBarHookUPP = UniversalProcPtr;
  110.  
  111. CONST
  112.     uppMenuDefProcInfo = $0000FF80;
  113.     uppMenuBarDefProcInfo = $00003AB0;
  114.     uppMenuHookProcInfo = $00000000;
  115.     uppMBarHookProcInfo = $000000CF;
  116.  
  117. FUNCTION NewMenuDefProc(userRoutine: MenuDefProcPtr): MenuDefUPP;
  118.     {$IFC NOT GENERATINGCFM }
  119.     INLINE $2E9F;
  120.     {$ENDC}
  121.  
  122. FUNCTION NewMenuBarDefProc(userRoutine: MenuBarDefProcPtr): MenuBarDefUPP;
  123.     {$IFC NOT GENERATINGCFM }
  124.     INLINE $2E9F;
  125.     {$ENDC}
  126.  
  127. FUNCTION NewMenuHookProc(userRoutine: MenuHookProcPtr): MenuHookUPP;
  128.     {$IFC NOT GENERATINGCFM }
  129.     INLINE $2E9F;
  130.     {$ENDC}
  131.  
  132. FUNCTION NewMBarHookProc(userRoutine: MBarHookProcPtr): MBarHookUPP;
  133.     {$IFC NOT GENERATINGCFM }
  134.     INLINE $2E9F;
  135.     {$ENDC}
  136.  
  137. PROCEDURE CallMenuDefProc(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER; userRoutine: MenuDefUPP);
  138.     {$IFC NOT GENERATINGCFM}
  139.     INLINE $205F, $4E90;
  140.     {$ENDC}
  141.  
  142. FUNCTION CallMenuBarDefProc(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT; userRoutine: MenuBarDefUPP): LONGINT;
  143.     {$IFC NOT GENERATINGCFM}
  144.     INLINE $205F, $4E90;
  145.     {$ENDC}
  146.  
  147. PROCEDURE CallMenuHookProc(userRoutine: MenuHookUPP);
  148.     {$IFC NOT GENERATINGCFM}
  149.     INLINE $205F, $4E90;
  150.     {$ENDC}
  151.  
  152. FUNCTION CallMBarHookProc(VAR menuRect: Rect; userRoutine: MBarHookUPP): INTEGER;
  153.     {$IFC NOT GENERATINGCFM}
  154.     {To be implemented:  Glue to move parameters into registers.}
  155.     {$ENDC}
  156. FUNCTION GetMBarHeight: INTEGER;
  157.     {$IFC NOT GENERATINGCFM}
  158.     INLINE $3EB8, $0BAA;
  159.     {$ENDC}
  160. FUNCTION NewMenu(menuID: INTEGER; menuTitle: Str255): MenuRef;
  161.     {$IFC NOT GENERATINGCFM}
  162.     INLINE $A931;
  163.     {$ENDC}
  164. FUNCTION GetMenu(resourceID: INTEGER): MenuRef;
  165.     {$IFC NOT GENERATINGCFM}
  166.     INLINE $A9BF;
  167.     {$ENDC}
  168. PROCEDURE AppendMenu(menu: MenuRef; data: Str255);
  169.     {$IFC NOT GENERATINGCFM}
  170.     INLINE $A933;
  171.     {$ENDC}
  172. PROCEDURE InsertMenu(theMenu: MenuRef; beforeID: INTEGER);
  173.     {$IFC NOT GENERATINGCFM}
  174.     INLINE $A935;
  175.     {$ENDC}
  176. PROCEDURE DeleteMenu(menuID: INTEGER);
  177.     {$IFC NOT GENERATINGCFM}
  178.     INLINE $A936;
  179.     {$ENDC}
  180. PROCEDURE AppendResMenu(theMenu: MenuRef; theType: ResType);
  181.     {$IFC NOT GENERATINGCFM}
  182.     INLINE $A94D;
  183.     {$ENDC}
  184. PROCEDURE InsertMenuItem(theMenu: MenuRef; itemString: Str255; afterItem: INTEGER);
  185.     {$IFC NOT GENERATINGCFM}
  186.     INLINE $A826;
  187.     {$ENDC}
  188. PROCEDURE SetMenuItemText(theMenu: MenuRef; item: INTEGER; itemString: Str255);
  189.     {$IFC NOT GENERATINGCFM}
  190.     INLINE $A947;
  191.     {$ENDC}
  192. PROCEDURE GetMenuItemText(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  193.     {$IFC NOT GENERATINGCFM}
  194.     INLINE $A946;
  195.     {$ENDC}
  196. PROCEDURE SetItemMark(theMenu: MenuRef; item: INTEGER; markChar: CharParameter);
  197.     {$IFC NOT GENERATINGCFM}
  198.     INLINE $A944;
  199.     {$ENDC}
  200. PROCEDURE GetItemMark(theMenu: MenuRef; item: INTEGER; VAR markChar: CharParameter);
  201.     {$IFC NOT GENERATINGCFM}
  202.     INLINE $A943;
  203.     {$ENDC}
  204. PROCEDURE SetItemCmd(theMenu: MenuRef; item: INTEGER; cmdChar: CharParameter);
  205.     {$IFC NOT GENERATINGCFM}
  206.     INLINE $A84F;
  207.     {$ENDC}
  208. PROCEDURE GetItemCmd(theMenu: MenuRef; item: INTEGER; VAR cmdChar: CharParameter);
  209.     {$IFC NOT GENERATINGCFM}
  210.     INLINE $A84E;
  211.     {$ENDC}
  212. PROCEDURE SetItemIcon(theMenu: MenuRef; item: INTEGER; iconIndex: INTEGER);
  213.     {$IFC NOT GENERATINGCFM}
  214.     INLINE $A940;
  215.     {$ENDC}
  216. PROCEDURE GetItemIcon(theMenu: MenuRef; item: INTEGER; VAR iconIndex: Byte);
  217.     {$IFC NOT GENERATINGCFM}
  218.     INLINE $A93F;
  219.     {$ENDC}
  220. PROCEDURE SetItemStyle(theMenu: MenuRef; item: INTEGER; chStyle: StyleParameter);
  221.     {$IFC NOT GENERATINGCFM}
  222.     INLINE $A942;
  223.     {$ENDC}
  224. PROCEDURE GetItemStyle(theMenu: MenuRef; item: INTEGER; VAR chStyle: Style);
  225. FUNCTION GetMenuHandle(menuID: INTEGER): MenuRef;
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $A949;
  228.     {$ENDC}
  229. PROCEDURE CalcMenuSize(theMenu: MenuRef);
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $A948;
  232.     {$ENDC}
  233. PROCEDURE DisableItem(theMenu: MenuRef; item: INTEGER);
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $A93A;
  236.     {$ENDC}
  237. PROCEDURE EnableItem(theMenu: MenuRef; item: INTEGER);
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $A939;
  240.     {$ENDC}
  241. PROCEDURE FlashMenuBar(menuID: INTEGER);
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $A94C;
  244.     {$ENDC}
  245. FUNCTION PopUpMenuSelect(menu: MenuRef; top: INTEGER; left: INTEGER; popUpItem: INTEGER): LONGINT;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $A80B;
  248.     {$ENDC}
  249. PROCEDURE DeleteMCEntries(menuID: INTEGER; menuItem: INTEGER);
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $AA60;
  252.     {$ENDC}
  253. FUNCTION GetMCInfo: MCTableHandle;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $AA61;
  256.     {$ENDC}
  257. PROCEDURE SetMCInfo(menuCTbl: MCTableHandle);
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $AA62;
  260.     {$ENDC}
  261. PROCEDURE DisposeMCInfo(menuCTbl: MCTableHandle);
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $AA63;
  264.     {$ENDC}
  265. FUNCTION GetMCEntry(menuID: INTEGER; menuItem: INTEGER): MCEntryPtr;
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $AA64;
  268.     {$ENDC}
  269. PROCEDURE SetMCEntries(numEntries: INTEGER; menuCEntries: MCTablePtr);
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $AA65;
  272.     {$ENDC}
  273. PROCEDURE DrawMenuBar;
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $A937;
  276.     {$ENDC}
  277. PROCEDURE InvalMenuBar;
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $A81D;
  280.     {$ENDC}
  281. PROCEDURE InitProcMenu(resID: INTEGER);
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $A808;
  284.     {$ENDC}
  285. FUNCTION GetMenuBar: Handle;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $A93B;
  288.     {$ENDC}
  289. PROCEDURE SetMenuBar(menuList: Handle);
  290.     {$IFC NOT GENERATINGCFM}
  291.     INLINE $A93C;
  292.     {$ENDC}
  293. FUNCTION SystemEdit(editCmd: INTEGER): BOOLEAN;
  294.     {$IFC NOT GENERATINGCFM}
  295.     INLINE $A9C2;
  296.     {$ENDC}
  297. PROCEDURE SystemMenu(menuResult: LONGINT);
  298.     {$IFC NOT GENERATINGCFM}
  299.     INLINE $A9B5;
  300.     {$ENDC}
  301. FUNCTION GetNewMBar(menuBarID: INTEGER): Handle;
  302.     {$IFC NOT GENERATINGCFM}
  303.     INLINE $A9C0;
  304.     {$ENDC}
  305. PROCEDURE ClearMenuBar;
  306.     {$IFC NOT GENERATINGCFM}
  307.     INLINE $A934;
  308.     {$ENDC}
  309. PROCEDURE CheckItem(theMenu: MenuRef; item: INTEGER; checked: BOOLEAN);
  310.     {$IFC NOT GENERATINGCFM}
  311.     INLINE $A945;
  312.     {$ENDC}
  313. FUNCTION CountMItems(theMenu: MenuRef): INTEGER;
  314.     {$IFC NOT GENERATINGCFM}
  315.     INLINE $A950;
  316.     {$ENDC}
  317. PROCEDURE SetMenuFlash(count: INTEGER);
  318.     {$IFC NOT GENERATINGCFM}
  319.     INLINE $A94A;
  320.     {$ENDC}
  321. PROCEDURE InitMenus;
  322.     {$IFC NOT GENERATINGCFM}
  323.     INLINE $A930;
  324.     {$ENDC}
  325. {$IFC OLDROUTINENAMES }
  326. PROCEDURE AddResMenu(theMenu: MenuRef; theType: ResType);
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $A94D;
  329.     {$ENDC}
  330. PROCEDURE InsMenuItem(theMenu: MenuRef; itemString: Str255; afterItem: INTEGER);
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $A826;
  333.     {$ENDC}
  334. PROCEDURE DelMenuItem(theMenu: MenuRef; item: INTEGER);
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $A952;
  337.     {$ENDC}
  338. PROCEDURE SetItem(theMenu: MenuRef; item: INTEGER; itemString: Str255);
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $A947;
  341.     {$ENDC}
  342. PROCEDURE GetItem(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  343.     {$IFC NOT GENERATINGCFM}
  344.     INLINE $A946;
  345.     {$ENDC}
  346. FUNCTION GetMHandle(menuID: INTEGER): MenuRef;
  347.     {$IFC NOT GENERATINGCFM}
  348.     INLINE $A949;
  349.     {$ENDC}
  350. PROCEDURE DelMCEntries(menuID: INTEGER; menuItem: INTEGER);
  351.     {$IFC NOT GENERATINGCFM}
  352.     INLINE $AA60;
  353.     {$ENDC}
  354. PROCEDURE DispMCInfo(menuCTbl: MCTableHandle);
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $AA63;
  357.     {$ENDC}
  358. {$ENDC}
  359. FUNCTION MenuKey(ch: CharParameter): LONGINT;
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $A93E;
  362.     {$ENDC}
  363. FUNCTION MenuSelect(startPt: Point): LONGINT;
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $A93D;
  366.     {$ENDC}
  367. FUNCTION MenuChoice: LONGINT;
  368.     {$IFC NOT GENERATINGCFM}
  369.     INLINE $AA66;
  370.     {$ENDC}
  371. PROCEDURE DisposeMenu(theMenu: MenuRef);
  372.     {$IFC NOT GENERATINGCFM}
  373.     INLINE $A932;
  374.     {$ENDC}
  375. PROCEDURE DeleteMenuItem(theMenu: MenuRef; item: INTEGER);
  376.     {$IFC NOT GENERATINGCFM}
  377.     INLINE $A952;
  378.     {$ENDC}
  379. PROCEDURE HiliteMenu(menuID: INTEGER);
  380.     {$IFC NOT GENERATINGCFM}
  381.     INLINE $A938;
  382.     {$ENDC}
  383. PROCEDURE InsertResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER);
  384.     {$IFC NOT GENERATINGCFM}
  385.     INLINE $A951;
  386.     {$ENDC}
  387. PROCEDURE InsertFontResMenu(theMenu: MenuRef; afterItem: INTEGER; scriptFilter: INTEGER);
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $303C, $0400, $A825;
  390.     {$ENDC}
  391. PROCEDURE InsertIntlResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER; scriptFilter: INTEGER);
  392.     {$IFC NOT GENERATINGCFM}
  393.     INLINE $303C, $0601, $A825;
  394.     {$ENDC}
  395. {$ENDC}
  396. {$ALIGN RESET}
  397. {$POP}
  398.  
  399. {$SETC UsingIncludes := MenusIncludes}
  400.  
  401. {$ENDC} {__MENUS__}
  402.  
  403. {$IFC NOT UsingIncludes}
  404.  END.
  405. {$ENDC}
  406.